#ifndef GROUP_COMMAND_H_
#define GROUP_COMMAND_H_

#include "command.h"

#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4200)
#endif          

#pragma pack(1)
namespace Cmd {
        enum {
                SCMD_GROUP_NULL                         = 0x0000,
                SCMD_GROUP_CREATE_REQ                   = 0x0002,       // 请求建群
                SCMD_GROUP_CREATE_RES                   = 0x0003,       // 建群结果返回
                SCMD_GROUP_DISSOLVE_REQ                 = 0x0004,       // 请求解散群
                SCMD_GROUP_DISSOLVE_RES                 = 0x0005,       // 解散群结果返回
                SCMD_GROUP_DISSOLVE_NOTIFY              = 0x0006,       // 解散群通知群内成员
                SCMD_GROUP_LIST_REQ                     = 0x0007,       // 请求群列表
                SCMD_GROUP_LIST_RES                     = 0x0008,       // 请求群列表返回
                SCMD_GROUP_BASE_INFO_REQ                = 0x0009,       // 请求群的基本信息.(用于登录后显示群列表)
                SCMD_GROUP_BASE_INFO_RES                = 0x000A,       // 请求群的基本信息返回.
                SCMD_GROUP_INFO_MANAGER_LIST_REQ        = 0x000B,       // 请求群管理员列表
                SCMD_GROUP_INFO_MANAGER_LIST_RES        = 0x000C,       // 请求群管理员列表返回
                SCMD_GROUP_INFO_REQ                     = 0x000D,       // 请求群信息.(第一次打开设置界面的时候才能请求，其他场景不要请求。)
                SCMD_GROUP_INFO_RES                     = 0x000E,       // 请求群信息返回.(include: name, instruction, tags)
                SCMD_GROUP_INFO_NAME_SET_REQ            = 0x000F,       // 设置群名称
                SCMD_GROUP_INFO_NAME_SET_RES            = 0x0010,       // 设置群名称返回
                SCMD_GROUP_INFO_NAME_SET_NOTIFY         = 0x0011,       // 设置群名称通知群成员
                SCMD_GROUP_INFO_INTRO_SET_REQ           = 0x0012,       // 设置群简介
                SCMD_GROUP_INFO_INTRO_SET_RES           = 0x0013,       // 设置群简介返回
                SCMD_GROUP_INFO_INTRO_SET_NOTIFY        = 0x0014,       // 设置群简介通知群成员
                SCMD_GROUP_INFO_TAGS_SET_REQ            = 0x0015,       // 设置群标签
                SCMD_GROUP_INFO_TAGS_SET_RES            = 0x0016,       // 设置群标签返回
                SCMD_GROUP_INFO_TAGS_SET_NOTIFY         = 0x0017,       // 设置群标签通知群成员
                SCMD_GROUP_INFO_COMMENT_REQ             = 0x0018,       // 请求群公告
                SCMD_GROUP_INFO_COMMENT_RES             = 0x0019,       // 请求群公告返回
                SCMD_GROUP_INFO_COMMENT_SET_REQ         = 0x001A,       // 设置群公告
                SCMD_GROUP_INFO_COMMENT_SET_RES         = 0x001B,       // 设置群公告返回
                SCMD_GROUP_INFO_COMMENT_SET_NOTIFY      = 0x001C,       // 设置群公告通知群成员
                SCMD_GROUP_AVATAR_SET_REQ               = 0x001D,       // 设置群图标
                SCMD_GROUP_AVATAR_SET_RES               = 0x001E,       // 设置群图标返回
                SCMD_GROUP_AVATAR_SET_NOTIFY            = 0x001F,       // 设置群图标通知群成员
                SCMD_GROUP_CHAT_MSG_OLD                 = 0x0020,       // 群内聊天消息(旧,废弃)
                SCMD_GROUP_ADD_USER_INVITE_REQ          = 0x0021,       // 邀请用户入群-邀请者发给服务器
                SCMD_GROUP_ADD_USER_INVITE_REQ_TO_USER  = 0x0022,       // 邀请用户入群-服务器发给被邀请者
                SCMD_GROUP_ADD_USER_INVITE_RES_FROM_USER= 0x0023,       // 邀请用户入群-被邀请者返回给服务器
                SCMD_GROUP_ADD_USER_INVITE_RES          = 0x0024,       // 邀请用户入群-服务器返回结果给邀请者/和被邀请者
                SCMD_GROUP_ADD_USER_INVITE_RESULT_NOTIFY_MANAGER        = 0x0025,       // 邀请用户入群-服务器发送通知消息给所有管理员
                SCMD_GROUP_ADD_USER_JOIN_REQ            = 0x0026,       // 用户申请入群
                SCMD_GROUP_ADD_USER_JOIN_REQ_TO_MANAGER = 0x0027,       // 用户申请入群-服务器发送申请给管理员
                SCMD_GROUP_ADD_USER_JOIN_RES_FROM_MANAGER       = 0x0028,       // 用户申请入群-管理员返回处理结果给服务器
                SCMD_GROUP_ADD_USER_JOIN_RES            = 0x0029,       // 用户申请入群-申请结果
                SCMD_GROUP_ADD_USER_JOIN_RESULT_NOTIFY_MANAGER  = 0x002A,       // 用户申请入群-处理结果通知给所有管理员
                SCMD_GROUP_ADD_USER_NOTIFY              = 0x002B,       // 通知群内的用户新用户入群
                SCMD_GROUP_ADD_USER_NOTIFY_HIM          = 0x002C,       // 通知加入的用户进群成功
                SCMD_GROUP_DEL_USER_KICK_REQ            = 0x002D,       // 管理员踢人
                SCMD_GROUP_DEL_USER_KICK_NOTIFY_MANAGER = 0x002E,       // 管理员踢人-结果通知其所有理员
                SCMD_GROUP_DEL_USER_KICK_NOTIFY_HIM     = 0x002F,       // 管理员踢人-通知被踢用户
                SCMD_GROUP_DEL_USER_QUIT_REQ            = 0x0030,       // 用户退群-请求
                SCMD_GROUP_DEL_USER_QUIT_RES            = 0x0031,       // 用户退群-返回结果
                SCMD_GROUP_DEL_USER_QUIT_NOTIFY_MANAGER = 0x0032,       // 用户退群-通知所有管理员
                SCMD_GROUP_DEL_USER_NOTIFY              = 0x0033,       // 群内由用户减少,通知群成员
                SCMD_GROUP_USER_LIST_REQ                = 0x0034,       // 请求群成员列表
                SCMD_GROUP_USER_LIST_RES                = 0x0035,       // 请求群成员列表返回
                SCMD_GROUP_USER_CARD_SET_REQ            = 0x0036,       // 设置群名片
                SCMD_GROUP_USER_CARD_SET_RES            = 0x0037,       // 设置群名片-返回
                SCMD_GROUP_USER_CARD_SET_NOTIFY         = 0x0038,       // 设置群名片-通知群成员
                SCMD_GROUP_USER_STATE_NOTIRY            = 0x0039,       // 用户状态改变,通知群成员
                SCMD_GROUP_MANAGER_SET_REQ              = 0x003A,       // 设置管理员
                SCMD_GROUP_MANAGER_SET_RES              = 0x003B,       // 设置管理员-返回
                SCMD_GROUP_MANAGER_SET_NOTIFY           = 0x003C,       // 设置管理员-通知群成员
                SCMD_GROUP_OFFLINE_MSG_REQ              = 0x003D,       // 请求群离线消息
                SCMD_GROUP_LAST_CHAT_TIME_REQ           = 0x003E,       // 请求最后聊天时间
                SCMD_GROUP_LAST_CHAT_TIME_RES           = 0x003F,       // 请求最后聊天时间-返回
                SCMD_GROUP_NUM_LIMIT_REQ                = 0x0040,       // 请求群成员上限
                SCMD_GROUP_NUM_LIMIT_RES                = 0x0041,       // 请求群成员上限-返回
                SCMD_GROUP_WEB_CREATE_NOTIFY_OWNER      = 0x0042,       // 后台创建群后通知群主
                SCMD_GROUP_WEB_MODIFY_INFO_NOTIFY       = 0x0043,       // 后台修改群信息通知群成员
                SCMD_GROUP_ADD_USER_JOIN_FAIL_TO_MANAGER= 0x0044,       // 用户申请入群加入失败通知管理员
                SCMD_GROUP_INVITED_USER_LIST_REQ        = 0x0045,       // 请求已经邀请的用户列表
                SCMD_GROUP_INVITED_USER_LIST_RES        = 0x0046,       // 返回已经邀请的用户列表
                SCMD_GROUP_DEL_INVITED_USER_REQ         = 0x0047,       // 删除邀请列表中的某个用户
                SCMD_GROUP_DEL_INVITED_USER_RES         = 0x0048,       // 删除邀请列表中的某个用户-返回
                SCMD_GROUP_INVITED_USER_SIZE_REQ        = 0x0049,       // 请求已经邀请的用户数量
                SCMD_GROUP_INVITED_USER_SIZE_RES        = 0x004A,       // 请求已经邀请的用户数量-返回
                SCMD_GROUP_CHAT_MSG                     = 0x004B,       // 发送聊天消息
                SCMD_GROUP_CHAT_MSG_ACK                 = 0x004C,       // 接收到聊天消息后,返回给服务器ack.(定时返回;无变化不返回)
                SCMD_GROUP_INFO_FOR_APP_REQ             = 0x004D,       // 移动端请求群信息
                SCMD_GROUP_INFO_FOR_APP_RES             = 0x004E,       // 移动端请求群信息返回
                //TODO:add new subcmd HERE
                //...
                SCMD_GROUP_MAX                          = 0XFFFF
        };

        // 群的统一出错码
        enum {
                RETCODE_GROUP_NOT_EXIST = 0x10,             // 群不存在或者已经被解散
                RETCODE_ALREADY_IN_GROUP = 0x11,            // 用户已经在群中
                RETCODE_MAX = 0x80
        };

                
        //base group cmd struct
        struct stGroupBaseCmd:
                t_NullCmd

        {
                stGroupBaseCmd(WORD subcmd):
                        t_NullCmd(CMD_GROUP, subcmd)
                {
                        group_id_ = 0;
                }
                void setGroupID(const DWORD &gid)
                {
                        group_id_ = gid;
                }
                DWORD getGroupID() const 
                {
                        return group_id_;
                }
                DWORD group_id_;                        // 群ID
        };


        /*-------->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
        struct stGroupCreateReq:
                stGroupBaseCmd
        {
                stGroupCreateReq():
                        stGroupBaseCmd(SCMD_GROUP_CREATE_REQ)
                {
                        bzero(group_name_, sizeof(group_name_));
                        bzero(group_intro_, sizeof(group_intro_));
                        bzero(group_tags_, sizeof(group_tags_));
                }
                char group_name_[MAX_NAME_SIZE+1];              // 群名称
                char group_intro_[MAX_GROUP_INTRO_SIZE+1];      // 群简介
                char group_tags_[MAX_GROUP_TAGS_SIZE+1];        // 群标签
        };
        struct stGroupCreateRes:
                stGroupBaseCmd
        {
                stGroupCreateRes():
                        stGroupBaseCmd(SCMD_GROUP_CREATE_RES)
                {
                        group_id_ = 0;
                        bzero(group_name_, sizeof(group_name_));
                        bzero(group_intro_, sizeof(group_intro_));
                        bzero(group_tags_, sizeof(group_tags_));
                        group_type_ = eGroupType_normal;
                        user_limit_ = GROUP_MEMBER_DEFAULT_LIMIT;
                        result_ = 0;
                }
                DWORD group_id_;                                // 群ID
                char group_name_[MAX_NAME_SIZE+1];              // 群名称
                char group_intro_[MAX_GROUP_INTRO_SIZE+1];      // 群简介
                char group_tags_[MAX_GROUP_TAGS_SIZE+1];        // 群标签
                WORD group_type_;       //eGroupType            // 群类型
                WORD user_limit_;                               // 人数上限
                BYTE result_; //0-fail 1-success 2-full         // 创建群结果
        };
        struct stGroupDissolveReq:
                stGroupBaseCmd
        {
                stGroupDissolveReq():
                        stGroupBaseCmd(SCMD_GROUP_DISSOLVE_REQ)
                {
                }
        };
        struct stGroupDissolveRes:
                stGroupBaseCmd
        {
                stGroupDissolveRes():
                        stGroupBaseCmd(SCMD_GROUP_DISSOLVE_RES)
                {
                        result_ = 0;
                }
                BYTE  result_; //0-fail 1-success               // 解散群结果
        };
        struct stGroupDissolveNotify:
                stGroupBaseCmd
        {
                stGroupDissolveNotify():
                        stGroupBaseCmd(SCMD_GROUP_DISSOLVE_NOTIFY)
                {
                        user_id_ = 0;
                        bzero(user_name_, sizeof(user_name_));
                        bzero(nick_name_, sizeof(nick_name_));
                        bzero(group_name_, sizeof(group_name_));
                }
                DWORD user_id_; //operator                      // 操作者ID
                char user_name_[MAX_ACCOUNT_SIZE+1];            // 操作者帐号
                char nick_name_[MAX_NAME_SIZE+1];               // 操作者昵称
                char group_name_[MAX_NAME_SIZE+1];              // 群名称
        };
        struct stGroupListReq:
                stGroupBaseCmd
        {
                stGroupListReq():
                        stGroupBaseCmd(SCMD_GROUP_LIST_REQ)
                {
                }
        };
        struct stGroupListRes:
                stGroupBaseCmd
        {
                stGroupListRes():
                        stGroupBaseCmd(SCMD_GROUP_LIST_RES)
                {
                        num_ = 0;
                }
                WORD num_;                                      // 群列表数量
                DWORD list_[0];                                 // 群ID列表
                DWORD getSize() {
                        return sizeof(*this) + num_*sizeof(list_[0]);
                }
        };
        struct stGroupBaseInfoReq:
                stGroupBaseCmd
        {
                stGroupBaseInfoReq():
                        stGroupBaseCmd(SCMD_GROUP_BASE_INFO_REQ)
                {
                }
        };
        struct stGroupBaseInfoRes:
                stGroupBaseCmd
        {
                stGroupBaseInfoRes():
                        stGroupBaseCmd(SCMD_GROUP_BASE_INFO_RES)
                {
                        bzero(name_, sizeof(name_));
                        creator_id_ = 0;
                        create_time_= 0;
                        group_type_ = eGroupType_normal;
                        offline_msg_num_= 0;
                        user_limit_ = GROUP_MEMBER_DEFAULT_LIMIT;
                        manager_limit_  = GROUP_MANAGER_DEFAULT_LIMIT;
                        create_type_ = 0; 
                }
                char name_[MAX_NAME_SIZE+1];                    // 群名称
                DWORD creator_id_;                              // 创建者ID
                DWORD create_time_;                             // 创建时间
                WORD group_type_;       // eGroupType           // 群类型
                WORD offline_msg_num_;                          // 离线消息数量
                WORD user_limit_;                               // 人数上限
                WORD manager_limit_;                            // 管理员数上限
                BYTE create_type_;      // 0自己创建 1后台创建  // 创建类型
        };
        struct stGroupInfoManagerListReq:
                stGroupBaseCmd
        {
                stGroupInfoManagerListReq():
                        stGroupBaseCmd(SCMD_GROUP_INFO_MANAGER_LIST_REQ)
                {
                }
        };
        struct stGroupInfoManagerListRes:
                stGroupBaseCmd
        {
                stGroupInfoManagerListRes():
                        stGroupBaseCmd(SCMD_GROUP_INFO_MANAGER_LIST_RES)
                {
                        num_ = 0;
                }
                WORD num_;
                DWORD list_[0];
                DWORD getSize() {
                        return sizeof(*this)+num_*sizeof(list_[0]);
                }
        };
        struct stGroupInfoReq:
                stGroupBaseCmd
        {
                stGroupInfoReq():
                        stGroupBaseCmd(SCMD_GROUP_INFO_REQ)
                {
                }
        };
        struct stGroupInfoRes:
                stGroupBaseCmd
        {
                stGroupInfoRes():
                        stGroupBaseCmd(SCMD_GROUP_INFO_RES)
                {
                        bzero(name_, sizeof(name_));
                        bzero(intro_, sizeof(intro_));
                        bzero(tags_, sizeof(tags_));
                        bzero(avatar_, sizeof(avatar_));
                }
                char name_[MAX_NAME_SIZE+1];                    // 群名称
                char intro_[MAX_GROUP_INTRO_SIZE+1];            // 群简介
                char tags_[MAX_GROUP_TAGS_SIZE+1];              // 群标签
                char avatar_[MAX_AVATAR_SIZE+1];                // 群图标
        };
        struct stGroupInfoNameSetReq:
                stGroupBaseCmd
        {
                stGroupInfoNameSetReq():
                        stGroupBaseCmd(SCMD_GROUP_INFO_NAME_SET_REQ)
                {
                        bzero(name_, sizeof(name_));
                }
                char name_[MAX_NAME_SIZE+1];                    // 群名称
        };
        struct stGroupInfoNameSetRes:
                stGroupBaseCmd
        {
                stGroupInfoNameSetRes():
                        stGroupBaseCmd(SCMD_GROUP_INFO_NAME_SET_RES)
                {
                        ret_code_ = 0;
                }
                BYTE ret_code_; //0-fail 1-success              // 设置群名称结果
        };
        struct stGroupInfoNameSetNotify:
                stGroupBaseCmd
        {
                stGroupInfoNameSetNotify():
                        stGroupBaseCmd(SCMD_GROUP_INFO_NAME_SET_NOTIFY)
                {
                        user_id_ = 0;
                        bzero(name_, sizeof(name_));
                }
                DWORD user_id_;                                 // 成员ID
                char name_[MAX_NAME_SIZE+1];                    // 成员名称
        };
        struct stGroupInfoIntroSetReq:
                stGroupBaseCmd
        {
                stGroupInfoIntroSetReq():
                        stGroupBaseCmd(SCMD_GROUP_INFO_INTRO_SET_REQ)
                {
                        bzero(intro_, sizeof(intro_));
                }
                char intro_[MAX_GROUP_INTRO_SIZE+1];            // 群简介
        };
        struct stGroupInfoIntroSetRes:
                stGroupBaseCmd
        {
                stGroupInfoIntroSetRes():
                        stGroupBaseCmd(SCMD_GROUP_INFO_INTRO_SET_RES)
                {
                        ret_code_ = 0;
                }
                BYTE ret_code_; //0-fail 1-success              // 设置群简介结果
        };
        struct stGroupInfoIntroSetNotify:
                stGroupBaseCmd
        {
                stGroupInfoIntroSetNotify():
                        stGroupBaseCmd(SCMD_GROUP_INFO_INTRO_SET_NOTIFY)
                {
                        user_id_ = 0;
                        bzero(intro_, sizeof(intro_));
                }
                DWORD user_id_;                                 // 操作者ID
                char intro_[MAX_GROUP_INTRO_SIZE+1];            // 群简介
        };
        struct stGroupInfoTagsSetReq:
                stGroupBaseCmd
        {
                stGroupInfoTagsSetReq():
                        stGroupBaseCmd(SCMD_GROUP_INFO_TAGS_SET_REQ)
                {
                        bzero(tags_, sizeof(tags_));
                }
                char tags_[MAX_GROUP_TAGS_SIZE+1];              // 群标签
        };
        struct stGroupInfoTagsSetRes:
                stGroupBaseCmd
        {
                stGroupInfoTagsSetRes():
                        stGroupBaseCmd(SCMD_GROUP_INFO_TAGS_SET_RES)
                {
                        ret_code_ = 0;
                }
                BYTE ret_code_; //0-fail 1-success              // 设置群标签结果
        };
        struct stGroupInfoTagsSetNotify:
                stGroupBaseCmd
        {
                stGroupInfoTagsSetNotify():
                        stGroupBaseCmd(SCMD_GROUP_INFO_TAGS_SET_NOTIFY)
                {
                        user_id_ = 0;
                        bzero(tags_, sizeof(tags_));
                }
                DWORD user_id_;                                 // 操作者ID
                char  tags_[MAX_GROUP_TAGS_SIZE+1];             // 群标签
        };
        struct stGroupInfoCommentReq:
                stGroupBaseCmd
        {
                stGroupInfoCommentReq():
                        stGroupBaseCmd(SCMD_GROUP_INFO_COMMENT_REQ)
                {
                }
        };
        struct stGroupInfoCommentRes:
                stGroupBaseCmd
        {
                stGroupInfoCommentRes():
                        stGroupBaseCmd(SCMD_GROUP_INFO_COMMENT_RES)
                {
                        comment_len_ = 0;
                }
                WORD  comment_len_;                             // 群备注长度
                char  comment_data_[0];                         // 群备注
                DWORD getSize() {
                        return sizeof(*this)+comment_len_*sizeof(comment_data_[0]);
                }
        };
        struct stGroupInfoCommentSetReq:
                stGroupBaseCmd
        {
                stGroupInfoCommentSetReq():
                        stGroupBaseCmd(SCMD_GROUP_INFO_COMMENT_SET_REQ)
                {
                        comment_len_ = 0;
                }
                WORD  comment_len_;                             // 群备注长度
                char  comment_data_[0];                         // 群备注
                DWORD getSize() {
                        return sizeof(*this)+comment_len_*sizeof(comment_data_[0]);
                }
        };

        struct stGroupInfoCommentSetRes:
                stGroupBaseCmd
        {
                stGroupInfoCommentSetRes():
                        stGroupBaseCmd(SCMD_GROUP_INFO_COMMENT_SET_RES)
                {
                        ret_code_ = 0;
                }
                BYTE  ret_code_;        //0-fail 1-success      // 设置群备注结果
        };
        struct stGroupInfoCommentSetNotify:
                stGroupBaseCmd
        {
                stGroupInfoCommentSetNotify():
                        stGroupBaseCmd(SCMD_GROUP_INFO_COMMENT_SET_NOTIFY)
                {
                        user_id_ = 0;
                        comment_len_ = 0;
                }
                DWORD user_id_;                                 // 操作者ID
                WORD  comment_len_;                             // 群备注长度
                char  comment_data_[0];                         // 群备注
                DWORD getSize() {
                        return sizeof(*this)+comment_len_*sizeof(comment_data_[0]);
                }
        };
        struct stGroupAvatarSetReq:
                stGroupBaseCmd
        {
                stGroupAvatarSetReq():
                        stGroupBaseCmd(SCMD_GROUP_AVATAR_SET_REQ)
                {
                        bzero(avatar_, sizeof(avatar_));
                }
                char avatar_[MAX_AVATAR_SIZE+1];                // 群图标
        };
        struct stGroupAvatarSetRes:
                stGroupBaseCmd
        {
                stGroupAvatarSetRes():
                        stGroupBaseCmd(SCMD_GROUP_AVATAR_SET_RES)
                {
                        ret_code_ = 0;
                }
                BYTE ret_code_; //0-fail 1-success              // 设置群图标结果
        };
        struct stGroupAvatarSetNotify:
                stGroupBaseCmd
        {
                stGroupAvatarSetNotify():
                        stGroupBaseCmd(SCMD_GROUP_AVATAR_SET_NOTIFY)
                {
                        bzero(avatar_, sizeof(avatar_));
                }
                char avatar_[MAX_AVATAR_SIZE+1];                // 群图标
        };

        struct stGroupChatMsgOld:
                stGroupBaseCmd
        {
                stGroupChatMsgOld():
                        stGroupBaseCmd(SCMD_GROUP_CHAT_MSG_OLD)
                {
                        sender_id_ = 0;
                        msg_type_  = eChatMsgType_text;
                        msg_len_   = 0;
                }
                DWORD sender_id_;                               // 发送者ID
                BYTE  msg_type_;        //eChatMsgType          // 消息类型
                WORD  msg_len_;                                 // 消息长度
                char  msg_data_[0];                             // 消息内容
                DWORD getSize() {
                        return sizeof(*this)+msg_len_*sizeof(msg_data_[0]);
                }
        };
        struct stGroupAddUserInviteReq:
                stGroupBaseCmd
        {
                stGroupAddUserInviteReq():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_INVITE_REQ)
                {
                        user_id_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
        };
        struct stGroupAddUserInviteReqToUser:
                stGroupBaseCmd
        {
                stGroupAddUserInviteReqToUser():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_INVITE_REQ_TO_USER)
                {
                        invitor_id_ = 0;
                        bzero(invitor_account_, sizeof(invitor_account_));
                        bzero(invitor_nickname_, sizeof(invitor_nickname_));
                        bzero(group_name_, sizeof(group_name_));
                }
                DWORD invitor_id_; //群管理员                   // 邀请者ID
                char  invitor_account_[MAX_ACCOUNT_SIZE+1];     // 邀请者帐号
                char  invitor_nickname_[MAX_NAME_SIZE+1];       // 邀请者昵称
                char  group_name_[MAX_NAME_SIZE+1];             // 群名称
        };
        struct stGroupAddUserInviteResFromUser:
                stGroupBaseCmd
        {
                stGroupAddUserInviteResFromUser():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_INVITE_RES_FROM_USER)
                {
                        invitor_id_     = 0;
                        ret_code_       = 0;
                        bzero(deny_info_, sizeof(deny_info_));
                }
                DWORD invitor_id_; //发出邀请的管理员           // 邀请者ID
                BYTE  ret_code_;   //0-deny, 1-accept, 2-ignore // 邀请结果
                char  deny_info_[MAX_GROUP_DENY_INFO_SIZE+1];   // 拒绝信息
        };
        struct stGroupAddUserInviteRes:
                stGroupBaseCmd
        {
                stGroupAddUserInviteRes():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_INVITE_RES)
                {
                        user_id_        = 0;
                        ret_code_       = 0;
                        bzero(deny_info_, sizeof(deny_info_));
                        bzero(group_name_, sizeof(group_name_));
                }
                DWORD user_id_;                                 // 用户ID
                BYTE  ret_code_; //0-deny 1-accept 2-power limit 3-user num limit
                char  deny_info_[MAX_GROUP_DENY_INFO_SIZE+1];   // 拒绝信息
                char  group_name_[MAX_NAME_SIZE+1];             // 群名称
        };
        struct stGroupAddUserInviteResultNotifyManager:
                stGroupBaseCmd
        {
                stGroupAddUserInviteResultNotifyManager():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_INVITE_RESULT_NOTIFY_MANAGER)
                {
                        operator_id_    = 0;
                        user_id_        = 0;
                        bzero(user_name_, sizeof(user_name_));
                        bzero(user_nick_, sizeof(user_nick_));
                }
                DWORD operator_id_;                             // 邀请者
                DWORD user_id_;                                 // 被邀请者
                char  user_name_[MAX_ACCOUNT_SIZE+1];           // 被邀请用户帐号
                char  user_nick_[MAX_NAME_SIZE+1];              // 被邀请用户昵称
        };
        struct stGroupAddUserJoinReq:
                stGroupBaseCmd
        {
                stGroupAddUserJoinReq():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_JOIN_REQ)
                {
                        bzero(auth_info_, sizeof(auth_info_));
                        bzero(user_name_, sizeof(user_name_));
                        bzero(nick_name_, sizeof(nick_name_));
                }
                char auth_info_[MAX_GROUP_AUTH_INFO_SIZE+1];    // 授权信息
                char user_name_[MAX_ACCOUNT_SIZE+1];            // 用户帐号
                char nick_name_[MAX_NAME_SIZE+1];               // 用户昵称
        };
        struct stGroupAddUserJoinReqToManager:
                stGroupBaseCmd
        {
                stGroupAddUserJoinReqToManager():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_JOIN_REQ_TO_MANAGER)
                {
                        user_id_        = 0;
                        bzero(user_name_, sizeof(user_name_));
                        bzero(nick_name_, sizeof(nick_name_));
                        bzero(auth_info_, sizeof(auth_info_));
                }
                DWORD user_id_;                                 // 用户ID
                char  user_name_[MAX_ACCOUNT_SIZE+1];           // 用户帐号
                char  nick_name_[MAX_NAME_SIZE+1];              // 用户昵称
                char  auth_info_[MAX_GROUP_AUTH_INFO_SIZE+1];   // 授权信息
        };
        struct stGroupAddUserJoinResFromManager:
                stGroupBaseCmd
        {
                stGroupAddUserJoinResFromManager():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_JOIN_RES_FROM_MANAGER)
                {
                        user_id_        = 0;
                        ret_code_       = 0;
                        bzero(deny_info_, sizeof(deny_info_));
                }
                DWORD user_id_;                                 // 用户ID
                BYTE  ret_code_; //0-deny; 1-allow 2-ignore     // 允许用户加入结果
                char  deny_info_[MAX_GROUP_DENY_INFO_SIZE+1];   // 拒绝信息
        };
        struct stGroupAddUserJoinRes:
                stGroupBaseCmd
        {
                stGroupAddUserJoinRes():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_JOIN_RES)
                {
                        manager_id_     = 0;
                        bzero(group_name_, sizeof(group_name_));
                        bzero(manager_account_, sizeof(manager_account_));
                        bzero(manager_nickname_, sizeof(manager_nickname_));
                        ret_code_       = 0;
                        bzero(deny_info_, sizeof(deny_info_));
                }
                DWORD manager_id_;                              // 管理员ID
                char  group_name_[MAX_NAME_SIZE+1];             // 群名称
                char  manager_account_[MAX_ACCOUNT_SIZE+1];     // 管理员帐号
                char  manager_nickname_[MAX_NAME_SIZE+1];       // 管理员昵称
                BYTE  ret_code_; //0-deny; 1-allow 2-full       // 添加用户结果
                char  deny_info_[MAX_GROUP_DENY_INFO_SIZE+1];   // 拒绝信息
        };
        struct stGroupAddUserJoinResultNotifyManager:
                stGroupBaseCmd
        {
                stGroupAddUserJoinResultNotifyManager():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_JOIN_RESULT_NOTIFY_MANAGER)
                {
                        operator_id_    = 0;
                        user_id_        = 0;
                        bzero(user_name_, sizeof(user_name_));
                        bzero(nick_name_, sizeof(nick_name_));
                        ret_code_       = 0;
                }
                DWORD operator_id_;                             // 操作者ID
                DWORD user_id_;                                 // 用户ID
                char  user_name_[MAX_ACCOUNT_SIZE+1];           // 用户帐号
                char  nick_name_[MAX_NAME_SIZE+1];              // 用户昵称
                BYTE  ret_code_; //0-deny 1-accept              // 操作类型
        };
        struct stGroupAddUserNotify:
                stGroupBaseCmd
        {
                stGroupAddUserNotify():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_NOTIFY)
                {
                        user_id_ = 0;
                        bzero(user_name_, sizeof(user_name_));
                        bzero(nick_name_, sizeof(nick_name_));
                        state_   = USER_STATE_OFFLINE;
                }
                DWORD user_id_;                                 // 用户ID
                char  user_name_[MAX_ACCOUNT_SIZE+1];           // 用户帐号
                char  nick_name_[MAX_NAME_SIZE+1];              // 用户昵称
                BYTE  state_; //eIMOnlineStatus                 // 用户在线状态
        };
        struct stGroupAddUserNotifyHim:
                stGroupBaseCmd
        {
                stGroupAddUserNotifyHim():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_NOTIFY_HIM)
                {
                }
        };
        struct stGroupDelUserKickReq:
                stGroupBaseCmd
        {
                stGroupDelUserKickReq():
                        stGroupBaseCmd(SCMD_GROUP_DEL_USER_KICK_REQ)
                {
                        user_id_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
        };
        struct stGroupDelUserKickNotifyManager:
                stGroupBaseCmd
        {
                stGroupDelUserKickNotifyManager():
                        stGroupBaseCmd(SCMD_GROUP_DEL_USER_KICK_NOTIFY_MANAGER)
                {
                        manager_id_ = 0;
                        user_id_    = 0;
                        bzero(user_name_, sizeof(user_name_));
                        bzero(nick_name_, sizeof(nick_name_));
                }
                DWORD manager_id_;                              // 管理员ID
                DWORD user_id_;                                 // 用户ID
                char user_name_[MAX_ACCOUNT_SIZE+1];            // 用户帐号
                char nick_name_[MAX_NAME_SIZE+1];               // 用户昵称
        };
        struct stGroupDelUserKickNotifyHim:
                stGroupBaseCmd
        {
                stGroupDelUserKickNotifyHim():
                        stGroupBaseCmd(SCMD_GROUP_DEL_USER_KICK_NOTIFY_HIM)
                {
                        manager_id_ = 0;
                        bzero(manager_name_, sizeof(manager_name_));
                        bzero(manager_nick_, sizeof(manager_nick_));
                        bzero(group_name_, sizeof(group_name_));
                }
                DWORD manager_id_;                              // 管理员ID
                char manager_name_[MAX_ACCOUNT_SIZE+1];         // 管理员帐号
                char manager_nick_[MAX_NAME_SIZE+1];            // 管理员昵称
                char group_name_[MAX_NAME_SIZE+1];              // 群名称
        };
        struct stGroupDelUserQuitReq:
                stGroupBaseCmd
        {
                stGroupDelUserQuitReq():
                        stGroupBaseCmd(SCMD_GROUP_DEL_USER_QUIT_REQ)
                {
                }
        };
        struct stGroupDelUserQuitRes:
                stGroupBaseCmd
        {
                stGroupDelUserQuitRes():
                        stGroupBaseCmd(SCMD_GROUP_DEL_USER_QUIT_RES)
                {
                        ret_code_ = 0;
                }
                BYTE ret_code_; //0-fail 1-success              // 退出群结果
        };
        struct stGroupDelUserQuitNotifyManager:
                stGroupBaseCmd
        {
                stGroupDelUserQuitNotifyManager():
                        stGroupBaseCmd(SCMD_GROUP_DEL_USER_QUIT_NOTIFY_MANAGER)
                {
                        user_id_ = 0;
                        bzero(user_name_, sizeof(user_name_));
                        bzero(nick_name_, sizeof(nick_name_));
                }
                DWORD user_id_;                                 // 用户DI
                char  user_name_[MAX_ACCOUNT_SIZE+1];           // 用户帐号
                char  nick_name_[MAX_NAME_SIZE+1];              // 用户昵称
        };
        struct stGroupDelUserNotify:
                stGroupBaseCmd
        {
                stGroupDelUserNotify():
                        stGroupBaseCmd(SCMD_GROUP_DEL_USER_NOTIFY)
                {
                        user_id_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
        };
        struct stGroupUserListReq:
                stGroupBaseCmd
        {
                stGroupUserListReq():
                        stGroupBaseCmd(SCMD_GROUP_USER_LIST_REQ)
                {
                }
        };
        struct stGroupUserListRes:
                stGroupBaseCmd
        {
                stGroupUserListRes():
                        stGroupBaseCmd(SCMD_GROUP_USER_LIST_RES)
                {
                        num_    = 0;
                        finish  = 0;
                }
                BYTE finish;    //0-no, 1-finish                // 结束标记
                WORD num_;                                      // 列表大小
                struct {
                        DWORD user_id_;                         // 用户ID
                        char  user_name_[MAX_ACCOUNT_SIZE+1];   // 用户帐号
                        char  nick_name_[MAX_NAME_SIZE+1];      // 用户昵称
                        char  user_card_[MAX_NAME_SIZE+1];      // 群名片
                        BYTE  identity_;//eGroupIdentity        // 权限
                        BYTE  state_;   //eIMOnlineStatus       // 在线状态
                        BYTE  sex_;     //eSexType              // 性别
                } user_list_[0];
                DWORD getSize() {
                        return sizeof(*this)+num_*sizeof(user_list_[0]);
                }
        };
        struct stGroupUserCardSetReq:
                stGroupBaseCmd
        {
                stGroupUserCardSetReq():
                        stGroupBaseCmd(SCMD_GROUP_USER_CARD_SET_REQ)
                {
                        user_id_ = 0;
                        bzero(nickname_, sizeof(nickname_));
                        sex_ = eSexType_female;
                }
                DWORD user_id_;                                 // 用户ID
                char  nickname_[MAX_NAME_SIZE+1];               // 群名片
                BYTE  sex_;                                     // 性别
        };
        struct stGroupUserCardSetRes:
                stGroupBaseCmd
        {
                stGroupUserCardSetRes():
                        stGroupBaseCmd(SCMD_GROUP_USER_CARD_SET_RES)
                {
                        user_id_ = 0;
                        ret_code_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
                BYTE  ret_code_;//0-fail 1-success              // 设置群名片结果
        };
        struct stGroupUserCardSetNotify:
                stGroupBaseCmd
        {
                stGroupUserCardSetNotify():
                        stGroupBaseCmd(SCMD_GROUP_USER_CARD_SET_NOTIFY)
                {
                        user_id_ = 0;
                        bzero(nickname_, sizeof(nickname_));
                        sex_ = eSexType_female;
                }
                DWORD user_id_;                                 // 用户ID
                char  nickname_[MAX_NAME_SIZE+1];               // 用户昵称
                BYTE  sex_;     //eSexType;                     // 性别
        };
        struct stGroupUserStateNotify:
                stGroupBaseCmd
        {
                stGroupUserStateNotify():
                        stGroupBaseCmd(SCMD_GROUP_USER_STATE_NOTIRY)
                {
                        user_id_ = 0;
                        state_   = USER_STATE_OFFLINE;
                }
                DWORD user_id_;                                 // 用户ID
                BYTE  state_;   //eIMOnlineStatus               // 在线状态
        };
        struct stGroupManagerSetReq:
                stGroupBaseCmd
        {
                stGroupManagerSetReq():
                        stGroupBaseCmd(SCMD_GROUP_MANAGER_SET_REQ)
                {
                        user_id_ = 0;
                        type_   = eGroupIdentity_normal;
                }
                DWORD user_id_;                                 // 用户ID
                BYTE  type_;    //eGroupIdentity                // 身份类型
        };
        struct stGroupManagerSetRes:
                stGroupBaseCmd
        {
                stGroupManagerSetRes():
                        stGroupBaseCmd(SCMD_GROUP_MANAGER_SET_RES)
                {
                        user_id_ = 0;
                        ret_code_= 0;
                }
                DWORD user_id_;                                 // 用户ID
                BYTE  ret_code_;//0-fail;     1-success         // 设置身份结果
        };

        struct stGroupManagerSetNotify:
                stGroupBaseCmd
        {
                stGroupManagerSetNotify():
                        stGroupBaseCmd(SCMD_GROUP_MANAGER_SET_NOTIFY)
                {
                        operator_id_    =  0;
                        bzero(operator_name_, sizeof(operator_name_));
                        bzero(operator_nick_, sizeof(operator_nick_));
                        user_id_        = 0;
                        bzero(user_name_, sizeof(user_name_));
                        bzero(user_nick_, sizeof(user_nick_));
                        type_           = eGroupIdentity_normal;
                }
                DWORD operator_id_;                             // 操作者ID
                char  operator_name_[MAX_ACCOUNT_SIZE+1];       // 操作者帐号
                char  operator_nick_[MAX_NAME_SIZE+1];          // 操作者昵称
                DWORD user_id_;                                 // 用户ID
                char  user_name_[MAX_ACCOUNT_SIZE+1];           // 用户帐号
                char  user_nick_[MAX_NAME_SIZE+1];              // 用户昵称
                BYTE  type_;    //eGroupIdentity                // 身份类型
        };
        struct stGroupOfflineMsgReq:
                stGroupBaseCmd
        {
                stGroupOfflineMsgReq():
                        stGroupBaseCmd(SCMD_GROUP_OFFLINE_MSG_REQ)
                {
                        num_ = 0;
                }
                WORD num_;                                      // 消息数量
        };
        struct stGroupLastChatTimeReq:
                stGroupBaseCmd
        {
                stGroupLastChatTimeReq():
                        stGroupBaseCmd(SCMD_GROUP_LAST_CHAT_TIME_REQ)
                {
                }
        };
        struct stGroupLastChatTimeRes:
                stGroupBaseCmd
        {
                stGroupLastChatTimeRes():
                        stGroupBaseCmd(SCMD_GROUP_LAST_CHAT_TIME_RES)
                {
                        time_ = 0;
                }
                DWORD time_;                                    // 最后的聊天时间
        };
        struct stGroupNumLimitReq:
                t_NullCmd
        {
                stGroupNumLimitReq():
                        t_NullCmd(CMD_GROUP, SCMD_GROUP_NUM_LIMIT_REQ)
                {
                }
        };
        struct stGroupNumLimitRes:
                t_NullCmd
        {
                stGroupNumLimitRes():
                        t_NullCmd(CMD_GROUP, SCMD_GROUP_NUM_LIMIT_RES)
                {
                        num_limit_ = DEFAULT_GROUP_NUM_LIMIT;
                }
                WORD num_limit_;                                // 成员数量上限
        };
        struct stGroupWebCreateNotifyOwner:
                stGroupBaseCmd
        {
                stGroupWebCreateNotifyOwner():
                        stGroupBaseCmd(SCMD_GROUP_WEB_CREATE_NOTIFY_OWNER)
                {
                }
        };
        struct stGroupWebModifyInfoNotify:
                stGroupBaseCmd
        {
                stGroupWebModifyInfoNotify():
                        stGroupBaseCmd(SCMD_GROUP_WEB_MODIFY_INFO_NOTIFY)
                {
                        owner_      = 0;
                        user_limit_ = 0;
                        bzero(name_, sizeof(name_));
                        bzero(intro_, sizeof(intro_));
                        bzero(tags_, sizeof(tags_));
                }
                DWORD owner_;                                   // 群主
                DWORD user_limit_;                              // 成员数量上限
                char name_[MAX_NAME_SIZE+1];                    // 群名称
                char intro_[MAX_GROUP_INTRO_SIZE+1];            // 群简介
                char tags_[MAX_GROUP_TAGS_SIZE+1];              // 群标签
        };
        struct stGroupAddUserJoinFailToManager:
                stGroupBaseCmd
        {
                stGroupAddUserJoinFailToManager():
                        stGroupBaseCmd(SCMD_GROUP_ADD_USER_JOIN_FAIL_TO_MANAGER)
                {
                        user_id_        = 0;
                        bzero(account_, sizeof(account_));
                        bzero(nickname_, sizeof(nickname_));
                        fail_reason_    = 0;
                }
                DWORD user_id_;                                 // 用户ID
                char  account_[MAX_ACCOUNT_SIZE+1];             // 用户帐号
                char  nickname_[MAX_NAME_SIZE+1];               // 用户昵称
                BYTE  fail_reason_; //0-fail, 1-full            // 失败原因
        };
        struct stGroupInvitedUserListReq:
                stGroupBaseCmd
        {
                stGroupInvitedUserListReq():
                        stGroupBaseCmd(SCMD_GROUP_INVITED_USER_LIST_REQ)
                {
                }
        };
        struct stGroupInvitedUserListRes:
                stGroupBaseCmd
        {
                stGroupInvitedUserListRes():
                        stGroupBaseCmd(SCMD_GROUP_INVITED_USER_LIST_RES)
                {
                        num_    = 0;
                }

                DWORD getSize() const
                {
                        return sizeof(*this)+num_*sizeof(user_list_[0]);
                }

                WORD num_;                                      // 用户列表数量
                struct {
                        DWORD user_id_;                         // 用户ID
                        char  user_name_[MAX_ACCOUNT_SIZE+1];   // 用户帐号
                        char  nick_name_[MAX_NAME_SIZE+1];      // 用户昵称
                        BYTE  sex_;     // eSexType             // 用户性别
                } user_list_[0];
        };
        struct stGroupDelInvitedUserReq:
                stGroupBaseCmd
        {
                stGroupDelInvitedUserReq():
                        stGroupBaseCmd(SCMD_GROUP_DEL_INVITED_USER_REQ)
                {
                        user_id_ = 0;
                }

                DWORD user_id_;                                 // 用户ID
        };
        struct stGroupDelInvitedUserRes:
                stGroupBaseCmd
        {
                stGroupDelInvitedUserRes():
                        stGroupBaseCmd(SCMD_GROUP_DEL_INVITED_USER_RES)
                {
                        user_id_ = 0;
                        ret_code_ = 0;
                }

                DWORD user_id_;                                 // 用户ID
                BYTE ret_code_;         // 0-成功 非0-失败      // 删除邀请用户结果
        };
        struct stGroupInvitedUserSizeReq:
                stGroupBaseCmd
        {
                stGroupInvitedUserSizeReq():
                        stGroupBaseCmd(SCMD_GROUP_INVITED_USER_SIZE_REQ)
                {
                }
        };
        struct stGroupInvitedUserSizeRes:
                stGroupBaseCmd
        {
                stGroupInvitedUserSizeRes():
                        stGroupBaseCmd(SCMD_GROUP_INVITED_USER_SIZE_RES)
                {
                        user_size_ = 0;
                }

                DWORD user_size_;                               // 被邀请用户数量
        };
        struct stGroupChatMsg:
                stGroupBaseCmd
        {
                stGroupChatMsg():
                        stGroupBaseCmd(SCMD_GROUP_CHAT_MSG)
                {
                        sender_id_ = 0;
                        msg_id_    = 0;
                        msg_type_  = eChatMsgType_text;
                        msg_len_   = 0;
                }
                DWORD sender_id_;                               // 发送者ID
                DWORD msg_id_;                                  // 消息ID
                BYTE  msg_type_;        //eChatMsgType          // 消息类型
                WORD  msg_len_;                                 // 消息长度
                char  msg_data_[0];                             // 消息内容
                DWORD getSize() {
                        return sizeof(*this)+msg_len_*sizeof(msg_data_[0]);
                }
        };
        struct stGroupChatMsgAck:
                stGroupBaseCmd
        {
                stGroupChatMsgAck():
                        stGroupBaseCmd(SCMD_GROUP_CHAT_MSG_ACK)
                {
                        msg_id_ = 0;
                }
                DWORD msg_id_;                                  // 消息ID
        };
        struct stGroupInfoForAppReq:
                stGroupBaseCmd
        {
                stGroupInfoForAppReq():
                        stGroupBaseCmd(SCMD_GROUP_INFO_FOR_APP_REQ)
                {
                }
        };
        struct stGroupInfoForAppRes:
                stGroupBaseCmd
        {
                stGroupInfoForAppRes():
                        stGroupBaseCmd(SCMD_GROUP_INFO_FOR_APP_RES)
                {
                        info_len_ = 0;
                }
                uint32_t size() {
                        return sizeof(*this)+info_len_*sizeof(info_data_[0]);
                }
                uint16_t info_len_;                             // 信息长度
                char info_data_[0]; //json                      // 信息内容
                //FIELDS:
                //nm    - name 
                //in    - intro
                //tp    - type
                //un    - user num
                //lt    - last chat time
        };
};

#pragma pack()

#ifdef _WIN32
#pragma warning( pop )
#endif

#endif//GROUP_COMMAND_H_
